package com.mt.mtyx.product.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mt.mtyx.common.utils.Helper;
import com.mt.mtyx.dto.product.SkuInfoDto;
import com.mt.mtyx.entity.product.SkuAttrValue;
import com.mt.mtyx.entity.product.SkuImage;
import com.mt.mtyx.entity.product.SkuInfo;
import com.mt.mtyx.entity.product.SkuPoster;
import com.mt.mtyx.mq.constant.RabbitMqConst;
import com.mt.mtyx.mq.service.RabbitMqService;
import com.mt.mtyx.product.mapper.SkuAttrValueMapper;
import com.mt.mtyx.product.mapper.SkuImageMapper;
import com.mt.mtyx.product.mapper.SkuInfoMapper;
import com.mt.mtyx.product.mapper.SkuPosterMapper;
import com.mt.mtyx.product.service.SkuInfoService;
import com.mt.mtyx.vo.product.SkuInfoQueryVo;
import com.mt.mtyx.vo.product.SkuInfoVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

/**
 * SKU业务层
 *
 * @author WMT
 * @Date 2023/7/20 10:35
 */
@Service
public class SkuInfoServiceImpl extends ServiceImpl<SkuInfoMapper, SkuInfo> implements SkuInfoService {

    @Autowired
    private SkuImageMapper skuImageMapper;

    @Autowired
    private SkuPosterMapper skuPosterMapper;

    @Autowired
    private SkuAttrValueMapper skuAttrValueMapper;

    @Autowired
    private RabbitMqService rabbitMqService;

    @Override
    public IPage<SkuInfo> selectAll(Page<SkuInfo> skuInfoPage, SkuInfoQueryVo queryVo) {
        // 1.获取查询条件
        String keyword = queryVo.getKeyword();
        Long categoryId = queryVo.getCategoryId();
        String skuType = queryVo.getSkuType();
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();

        // 2.封装查询条件
        if (!StringUtils.isEmpty(keyword)) {
            wrapper.like(SkuInfo::getSkuName, keyword);
        }
        if (!StringUtils.isEmpty(categoryId)) {
            wrapper.eq(SkuInfo::getCategoryId, categoryId);
        }
        if (!StringUtils.isEmpty(skuType)) {
            wrapper.like(SkuInfo::getSkuType, skuType);
        }
        wrapper.orderByDesc(SkuInfo::getUpdateTime);
        return baseMapper.selectPage(skuInfoPage, wrapper);
    }


    @Override
    public SkuInfoVo getDetails(Long id) {
        SkuInfoVo skuInfoVo = new SkuInfoVo();
        SkuInfo skuInfo = baseMapper.selectById(id);
        if (skuInfo != null) {
            BeanUtils.copyProperties(skuInfo, skuInfoVo);
        }
        return skuInfoVo;
    }

    @Override
    @Transactional
    public int insert(SkuInfoDto skuInfoDto) {
        LocalDateTime now = LocalDateTime.now();
        // 1.添加基本信息
        SkuInfo skuInfo = new SkuInfo();
        BeanUtils.copyProperties(skuInfoDto, skuInfo);
        Helper.setBaseProperties(skuInfo, now);
        int result = baseMapper.insert(skuInfo);

        // 2.添加sku海报
        List<SkuPoster> skuPosterList = skuInfoDto.getSkuPosterList();
        if (!CollectionUtils.isEmpty(skuPosterList)) {
            List<SkuPoster> posterList = skuPosterList.stream()
                    .peek(data -> {
                        data.setSkuId(skuInfo.getId());
                        Helper.setBaseProperties(data, now);
                    })
                    .collect(Collectors.toList());
            skuPosterMapper.batchSave(posterList);
        }

        // 3.保存sku图片
        List<SkuImage> skuImagesList = skuInfoDto.getSkuImagesList();
        if (!CollectionUtils.isEmpty(skuImagesList)) {
            List<SkuImage> imageList = skuImagesList.stream()
                    .peek(data -> {
                        data.setSkuId(skuInfo.getId());
                        Helper.setBaseProperties(data, now);
                    })
                    .collect(Collectors.toList());
            skuImageMapper.batchSave(imageList);
        }

        // 4.保存sku平台属性
        List<SkuAttrValue> skuAttrValueList = skuInfoDto.getSkuAttrValueList();
        if (!CollectionUtils.isEmpty(skuAttrValueList)) {
            List<SkuAttrValue> attrValueList = skuAttrValueList.stream()
                    .peek(data -> {
                        data.setSkuId(skuInfo.getId());
                        Helper.setBaseProperties(data, now);
                    })
                    .collect(Collectors.toList());
            skuAttrValueMapper.batchSave(attrValueList);
        }
        return result;
    }

    @Override
    public int update(SkuInfoDto skuInfoDto) {
        LocalDateTime now = LocalDateTime.now();
        // 1.修改sku信息
        SkuInfo skuInfo = new SkuInfo();
        BeanUtils.copyProperties(skuInfoDto, skuInfo);
        skuInfo.setUpdateTime(now);
        int result = baseMapper.updateById(skuInfo);

        Long skuId = skuInfoDto.getId();
        // 2.修改海报信息（先删除，再重新添加）
        LambdaQueryWrapper<SkuPoster> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SkuPoster::getSkuId, skuId);
        skuPosterMapper.delete(wrapper);
        List<SkuPoster> skuPosterList = skuInfoDto.getSkuPosterList();
        if (!CollectionUtils.isEmpty(skuPosterList)) {
            List<SkuPoster> posterList = skuPosterList.stream()
                    .peek(data -> {
                        data.setSkuId(skuInfo.getId());
                        Helper.setBaseProperties(data, now);
                    })
                    .collect(Collectors.toList());
            skuPosterMapper.batchSave(posterList);
        }

        // 3.修改图片信息
        LambdaQueryWrapper<SkuImage> imageLambdaQueryWrapper = new LambdaQueryWrapper<>();
        imageLambdaQueryWrapper.eq(SkuImage::getSkuId, skuId);
        skuImageMapper.delete(imageLambdaQueryWrapper);
        List<SkuImage> skuImagesList = skuInfoDto.getSkuImagesList();
        if (!CollectionUtils.isEmpty(skuImagesList)) {
            List<SkuImage> imageList = skuImagesList.stream()
                    .peek(data -> {
                        data.setSkuId(skuInfo.getId());
                        Helper.setBaseProperties(data, now);
                    })
                    .collect(Collectors.toList());
            skuImageMapper.batchSave(imageList);
        }

        // 4.修改平台属性
        LambdaQueryWrapper<SkuAttrValue> attrValueLambdaQueryWrapper = new LambdaQueryWrapper<>();
        attrValueLambdaQueryWrapper.eq(SkuAttrValue::getSkuId, skuId);
        skuAttrValueMapper.delete(attrValueLambdaQueryWrapper);
        List<SkuAttrValue> skuAttrValueList = skuInfoDto.getSkuAttrValueList();
        if (!CollectionUtils.isEmpty(skuAttrValueList)) {
            List<SkuAttrValue> attrValueList = skuAttrValueList.stream()
                    .peek(data -> {
                        data.setSkuId(skuInfo.getId());
                        Helper.setBaseProperties(data, now);
                    })
                    .collect(Collectors.toList());
            skuAttrValueMapper.batchSave(attrValueList);
        }

        return result;
    }

    @Override
    public int audit(Long id, Integer status) {
        SkuInfo skuInfo = baseMapper.selectById(id);
        skuInfo.setCheckStatus(status);
        return baseMapper.updateById(skuInfo);
    }

    @Override
    public int publish(Long skuId, Integer status) {
        int result;
        if (status == 1) { // 上架
            SkuInfo skuInfo = baseMapper.selectById(skuId);
            skuInfo.setPublishStatus(status);
            result = baseMapper.updateById(skuInfo);
            // 商品上架：发送mq消息同步es
            rabbitMqService.sendMessage(RabbitMqConst.EXCHANGE_GOODS_DIRECT,
                    RabbitMqConst.ROUTING_GOODS_UPPER, skuId);
        } else { // 下架
            SkuInfo skuInfo = baseMapper.selectById(skuId);
            skuInfo.setPublishStatus(status);
            result = baseMapper.updateById(skuInfo);
            // 商品下架：发送mq消息同步es
            rabbitMqService.sendMessage(RabbitMqConst.EXCHANGE_GOODS_DIRECT,
                    RabbitMqConst.ROUTING_GOODS_LOWER, skuId);
        }
        return result;
    }

    @Override
    public int isNewPerson(Long skuId, Integer status) {
        SkuInfo skuInfo = baseMapper.selectById(skuId);
        skuInfo.setIsNewPerson(status);
        return baseMapper.updateById(skuInfo);
    }

    @Override
    public List<SkuInfo> getSkuInfoListByIds(List<Long> ids) {
        return baseMapper.selectBatchIds(ids);
    }

    @Override
    public List<SkuInfo> getSkuInfoListByKeyword(String keyword) {
        return baseMapper.selectList(new LambdaQueryWrapper<SkuInfo>().like(SkuInfo::getSkuName, keyword));
    }

    @Override
    public List<SkuInfo> getNewPersonSkuInfoList() {
        // 根据库存排序，显示前三条数据
        Page<SkuInfo> pageParam = new Page<>(1,3);
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SkuInfo::getIsNewPerson, 1);
        wrapper.eq(SkuInfo::getPublishStatus, 1);
        wrapper.orderByDesc(SkuInfo::getStock);
        Page<SkuInfo> skuInfoPage = baseMapper.selectPage(pageParam, wrapper);
        if (skuInfoPage != null) {
            return skuInfoPage.getRecords();
        }
        return null;
    }


}
